//! 环境变量配置示例
//! 
//! 展示如何从环境变量加载配置并创建客户端

use binance_sdk_unified::{
    client::BinanceClientBuilder, ProductType, Environment, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
    // 初始化日志
    tracing_subscriber::fmt::init();

    println!("🔧 从环境变量加载配置");
    println!("========================");

    // 从环境变量加载API密钥
    let api_key = std::env::var("BINANCE_API_KEY")
        .unwrap_or_else(|_| "test_api_key".to_string());
    let secret_key = std::env::var("BINANCE_SECRET_KEY")
        .unwrap_or_else(|_| "test_secret_key".to_string());
    
    // 解析产品类型
    let product_type = match std::env::var("BINANCE_PRODUCT_TYPE")
        .unwrap_or_else(|_| "Spot".to_string())
        .as_str() 
    {
        "Spot" => ProductType::Spot,
        "UsdM" => ProductType::UsdM,
        "CoinM" => ProductType::CoinM,
        "Options" => ProductType::Options,
        "Portfolio" => ProductType::Portfolio,
        _ => {
            println!("⚠️  未知的产品类型，使用默认值: Spot");
            ProductType::Spot
        }
    };
    
    // 解析环境
    let environment = match std::env::var("BINANCE_ENVIRONMENT")
        .unwrap_or_else(|_| "Demo".to_string())
        .as_str() 
    {
        "Live" => Environment::Live,
        "Demo" => Environment::Demo,
        _ => {
            println!("⚠️  未知的环境，使用默认值: Demo");
            Environment::Demo
        }
    };
    
    // 解析超时和重试
    let timeout = std::env::var("BINANCE_TIMEOUT_SECONDS")
        .unwrap_or_else(|_| "30".to_string())
        .parse::<u64>()
        .unwrap_or_else(|_| {
            println!("⚠️  无效的超时时间，使用默认值: 30秒");
            30
        });
        
    let retry_count = std::env::var("BINANCE_RETRY_COUNT")
        .unwrap_or_else(|_| "3".to_string())
        .parse::<u32>()
        .unwrap_or_else(|_| {
            println!("⚠️  无效的重试次数，使用默认值: 3次");
            3
        });
    
    // 解析代理设置
    let http_proxy = std::env::var("BINANCE_HTTP_PROXY").ok();
    let ws_proxy = std::env::var("BINANCE_WS_PROXY").ok();
    
    // 打印配置信息
    println!("📋 加载的配置:");
    println!("   API Key: {}", if api_key.len() > 8 { 
        format!("{}...{}", &api_key[..4], &api_key[api_key.len()-4..]) 
    } else { 
        api_key.clone() 
    });
    println!("   Secret Key: {}", if secret_key.len() > 8 { 
        format!("{}...{}", &secret_key[..4], &secret_key[secret_key.len()-4..]) 
    } else { 
        secret_key.clone() 
    });
    println!("   产品类型: {:?}", product_type);
    println!("   环境: {:?}", environment);
    println!("   超时: {}秒", timeout);
    println!("   重试次数: {}次", retry_count);
    if let Some(proxy) = &http_proxy {
        println!("   HTTP代理: {}", proxy);
    }
    if let Some(proxy) = &ws_proxy {
        println!("   WebSocket代理: {}", proxy);
    }
    
    // 添加环境日志
    tracing::info!("[ENV_CONFIG] 产品类型: {:?}", product_type);
    tracing::info!("[ENV_CONFIG] 环境: {:?}", environment);
    tracing::info!("[ENV_CONFIG] 超时: {}秒", timeout);
    tracing::info!("[ENV_CONFIG] 重试次数: {}次", retry_count);
    if let Some(proxy) = &http_proxy {
        tracing::info!("[ENV_CONFIG] HTTP代理: {}", proxy);
    }
    if let Some(proxy) = &ws_proxy {
        tracing::info!("[ENV_CONFIG] WebSocket代理: {}", proxy);
    }
    
    // 创建客户端
    let client = BinanceClientBuilder::new(api_key, secret_key, product_type)
        .environment(environment)
        .timeout(timeout)
        .retry_count(retry_count)
        .proxy(http_proxy, ws_proxy)
        .build()?;

    println!("\n🚀 测试API连接...");
    
    // 测试公共API
    match client.rest().market().get_server_time().await {
        Ok(server_time) => {
            println!("✅ 服务器时间: {}", server_time.server_time);
            println!("✅ API连接成功！");
        },
        Err(e) => {
            println!("❌ 获取服务器时间失败: {}", e);
            println!("❌ API连接失败！");
        }
    }

    // 测试交易对信息
    match client.rest().market().get_exchange_info().await {
        Ok(exchange_info) => {
            println!("✅ 交易对数量: {}", exchange_info.symbols.len());
        },
        Err(e) => {
            println!("❌ 获取交易对信息失败: {}", e);
        }
    }

    println!("\n🎉 环境变量配置测试完成！");
    println!("================================");
    println!("💡 提示: 设置环境变量来测试不同的配置:");
    println!("   export BINANCE_API_KEY=\"your_api_key\"");
    println!("   export BINANCE_SECRET_KEY=\"your_secret_key\"");
    println!("   export BINANCE_PRODUCT_TYPE=\"UsdM\"");
    println!("   export BINANCE_ENVIRONMENT=\"Demo\"  # 支持 Live, Demo");
    println!("   export RUST_LOG=\"debug\"");

    Ok(())
}
